home *** CD-ROM | disk | FTP | other *** search
/ Acorn User: China / Acorn User China CD-ROM (UK) (Disc A) / Acorn User China CD-ROM (UK) (Disc A).bin / DEMON / MISC / NETLITE2.ARC / NET / c / FINGCLI < prev    next >
Encoding:
Text File  |  1993-04-10  |  8.1 KB  |  267 lines
  1. /*
  2.  *
  3.  *      Finger support...
  4.  *
  5.  *      Finger client routines.  Written by Michael T. Horne - KA7AXD.
  6.  *      Copyright 1988 by Michael T. Horne, All Rights Reserved.
  7.  *      Permission granted for non-commercial use and copying, provided
  8.  *      that this notice is retained.
  9.  *
  10.  */
  11.  
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <string.h>
  15. #include "dbox.h"
  16. #include "werr.h"
  17. #include "global.h"
  18. #include "mbuf.h"
  19. #include "timer.h"
  20. #include "internet.h"
  21. #include "icmp.h"
  22. #include "netuser.h"
  23. #include "tcp.h"
  24. #include "finger.h"
  25. #include "session.h"
  26. #include "misc.h"
  27. #include "domain.h"
  28.  
  29. #define FINGER_Connect   0
  30. #define FINGER_User      1
  31. #define FINGER_Host      2
  32.  
  33. static int finger(int32, char *, char *, char *, struct session *);
  34. static int finger_error(char *, char *, struct session *);
  35.  
  36. extern char     badhost[],
  37.                 hostname[],
  38.                 nospace[];
  39.  
  40. void start_finger(void)
  41. {
  42.         struct session *session;
  43.         char Host[256];
  44.         char User[56];
  45.         char buffer[80];
  46.         dbox d;
  47.  
  48.         if ((d = dbox_new("FINGER")) == NULL)
  49.                 return;
  50.  
  51.         dbox_setfield(d, FINGER_User, ""); 
  52.         dbox_setfield(d, FINGER_Host, "");
  53.         dbox_show(d);
  54.  
  55.         if (dbox_fillin(d) == FINGER_Connect)
  56.         {
  57.                  dbox_getfield(d, FINGER_User, User, 50);
  58.                  dbox_getfield(d, FINGER_Host, Host, 255);
  59.  
  60.                  /* Allocate a session descriptor */
  61.                  sprintf(buffer, "FINGER - %.60s", Host);
  62.                  if ((session = newsession(buffer)) == NULLSESSION)
  63.                  {
  64.                         werr(0, "Too many sessions");
  65.                         return;
  66.                  }
  67.  
  68.                  session->name  = strdup(Host);
  69.                  session->type  = RESOLVING;
  70.                  session->parse = NULLVFP;
  71.  
  72.                  sprintf(buffer, "Resolving %.60s ...\n", Host);
  73.                  Window_Write(session->window, buffer, strlen(buffer));
  74.  
  75.                  resolve_a(Host, User, NULLCHAR, session, finger, finger_error);   
  76.         }
  77.  
  78.         dbox_dispose(&d);
  79. }
  80.  
  81. static int finger_error(char *host, char *message, struct session *s)
  82. {
  83.         char buffer[80];
  84.  
  85.         sprintf(buffer, "Cannot FINGER %s - %s\n", host, message);
  86.         Window_Write(s->window, buffer, strlen(buffer));
  87.  
  88.         detachsession(s);
  89.  
  90.         return 0;  
  91. }
  92.  
  93. static int finger(int32 address, char *host, char *user, char *arg2, struct session *s)
  94. {
  95.         char buffer[80];
  96.         struct tcb *tcb;
  97.         struct socket lsocket, fsocket;
  98.         struct finger *finger;
  99.  
  100.         host = host;
  101.         arg2 = arg2;
  102.  
  103.         lsocket.address = ip_addr;
  104.         lsocket.port    = lport++;   
  105.  
  106.         fsocket.address = address;
  107.         fsocket.port    = FINGER_PORT;
  108.  
  109.         s->type  = FINGER;
  110.         s->addr  = fsocket.address;
  111.         s->parse = NULLVFP;
  112.         s->echo  = 0;
  113.         s->raw   = 0;
  114.  
  115.         if ((finger = alloc_finger()) == NULLFING) {
  116.                 Window_Write(s->window, nospace, strlen(nospace));
  117.                 detachsession(s);
  118.                 return(1);
  119.         }
  120.  
  121.         strcpy(buffer, user);
  122.         strcat(buffer, "\r\n");
  123.         finger->user = strdup(buffer);
  124.         s->cb.finger = finger;
  125.         finger->session = s;
  126.  
  127.         sprintf(buffer, "Trying [%s] ...\n", inet_ntoa(address));
  128.         Window_Write(s->window, buffer, strlen(buffer));
  129.  
  130.         tcb = open_tcp(&lsocket, &fsocket, TCP_ACTIVE, 0,
  131.          (void(*)())fingcli_rcv, NULLVFP, (void(*)())f_state, 0, (char *)finger);
  132.  
  133.         finger->tcb = tcb;
  134.         tcb->user = (char *)finger;
  135.         return 0;
  136. }
  137.  
  138. /*
  139.  *      Allocate a finger structure for the new session
  140.  */
  141. struct finger *alloc_finger(void)
  142. {
  143.         struct finger *tmp;
  144.  
  145.         if ((tmp = (struct finger *) malloc(sizeof(struct finger))) == NULLFING)
  146.                 return(NULLFING);
  147.         tmp->session = NULLSESSION;
  148.         tmp->user = (char *) NULL;
  149.         return(tmp);
  150. }
  151.  
  152. /*
  153.  *      Free a finger structure
  154.  */
  155. int free_finger(struct finger *finger)
  156. {
  157.         if (finger != NULLFING) {
  158.                 if (finger->session != NULLSESSION)
  159.                         detachsession(finger->session);
  160.                 if (finger->user != (char *) NULL)
  161.                         free(finger->user);
  162.                 free(finger);
  163.         }
  164.         return 0;
  165. }
  166.  
  167. /* Finger receiver upcall routine */
  168. void fingcli_rcv(register struct tcb *tcb, int16 cnt)
  169. {
  170.         struct finger *finger;
  171.         struct mbuf   *bp;
  172.         register char *buf;
  173.         register char *s;
  174.         char *line;
  175.  
  176.         /* Make sure it's a valid finger session */
  177.         if ((finger = (struct finger *)tcb->user) == NULLFING)
  178.                 return;
  179.  
  180.         if (recv_tcp(tcb, &bp, cnt) > 0) {
  181.                 if ((line = s = malloc(len_mbuf(bp) + 1)) == NULL)
  182.                 {
  183.                         Window_Write(finger->session->window, "Out of memory in FINGCLI\n", 25);
  184.                         free_p(bp);
  185.                         return;
  186.                 }
  187.                 while (bp != NULLBUF) {
  188.                         buf = bp->data;
  189.                         while(bp->cnt--) {
  190.                                 switch(*buf) {
  191.                                         case '\012':    /* ignore LF */
  192.                                         case '\032':    /* NO ^Z's! */
  193.                                                 break;
  194.                                         case '\015':
  195.                                                 *s++ = '\n';
  196.                                                 break;
  197.                                         default:
  198.                                                 *s++ = *buf;
  199.                                                 break;
  200.                                 }
  201.                                 buf++;
  202.                         }
  203.                         bp = free_mbuf(bp);
  204.                 }
  205.                 *s = '\0';
  206.                 Window_Write(finger->session->window, line, strlen(line));
  207.                 free(line);
  208.         }
  209. }
  210.  
  211. /* State change upcall routine */
  212. void f_state(register struct tcb *tcb, char old, char new)
  213. {
  214.         struct finger   *finger;
  215.         extern char     *tcpstates[];
  216.         extern char     *reasons[];
  217.         extern char     *unreach[];
  218.         extern char     *exceed[];
  219.         struct mbuf     *bp;
  220.         char buffer[50];
  221.  
  222.         old = old;
  223.  
  224.         finger = (struct finger *)tcb->user;
  225.  
  226.         switch(new){
  227.  
  228.         case CLOSE_WAIT:
  229.                 sprintf(buffer, "%s\n",tcpstates[new]);
  230.                 Window_Write(finger->session->window, buffer, strlen(buffer));
  231.                 close_tcp(tcb);
  232.                 break;
  233.         case CLOSED:    /* finish up */
  234.                 sprintf(buffer, "%s (%s", tcpstates[new], reasons[tcb->reason]);
  235.                 Window_Write(finger->session->window, buffer, strlen(buffer));
  236.                 if (tcb->reason == NETWORK){
  237.                         switch(tcb->type){
  238.                         case DEST_UNREACH:
  239.                                 sprintf(buffer,": %s unreachable",unreach[tcb->code]);
  240.                                 Window_Write(finger->session->window, buffer, strlen(buffer));
  241.                                 break;
  242.                         case TIME_EXCEED:
  243.                                 sprintf(buffer,": %s time exceeded",exceed[tcb->code]);
  244.                                 Window_Write(finger->session->window, buffer, strlen(buffer));
  245.                                 break;
  246.                         }
  247.                 }
  248.                 Window_Write(finger->session->window,")\n",2);
  249.                 if(finger != NULLFING) free_finger(finger);
  250.                 del_tcp(tcb);
  251.                 break;
  252.         case ESTABLISHED:
  253.                 sprintf(buffer,"%s\n",tcpstates[new]);
  254.                 Window_Write(finger->session->window,buffer,strlen(buffer));
  255.                 sprintf(buffer, "[%s]\n", finger->session->name);
  256.                 Window_Write(finger->session->window,buffer,strlen(buffer));
  257.                 bp = qdata(finger->user, (int16)strlen(finger->user));
  258.                 send_tcp(tcb, bp);
  259.                 break;   
  260.         default:
  261.                 sprintf(buffer,"%s\n",tcpstates[new]);
  262.                 Window_Write(finger->session->window,buffer,strlen(buffer));
  263.                 break;
  264.         }
  265. }
  266.  
  267.